.TH std::filesystem::path::concat,std::filesystem::path::operator+= 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::filesystem::path::concat,std::filesystem::path::operator+= \- std::filesystem::path::concat,std::filesystem::path::operator+=

.SH Synopsis
   path& operator+=( const path& p );                          \fB(1)\fP \fI(since C++17)\fP
   path& operator+=( const string_type& str );                 \fB(2)\fP \fI(since C++17)\fP
   path& operator+=( std::basic_string_view<value_type> str );
   path& operator+=( const value_type* ptr );                  \fB(3)\fP \fI(since C++17)\fP
   path& operator+=( value_type x );                           \fB(4)\fP \fI(since C++17)\fP
   template< class CharT >                                     \fB(5)\fP \fI(since C++17)\fP
   path& operator+=( CharT x );
   template< class Source >                                    \fB(6)\fP \fI(since C++17)\fP
   path& operator+=( const Source& source );
   template< class Source >                                    \fB(7)\fP \fI(since C++17)\fP
   path& concat( const Source& source );
   template< class InputIt >                                   \fB(8)\fP \fI(since C++17)\fP
   path& concat( InputIt first, InputIt last );

   Concatenates the current path and the argument

   1-3,6,7) Appends path(p).native() to the pathname stored in *this in the native
   format. This directly manipulates the value of native() and may not be portable
   between operating systems.
   4,5) Same as return *this += std::basic_string_view(&x, 1);.
   8) Same as return *this += path(first, last);.

   \fB(6)\fP and \fB(7)\fP participate in overload resolution only if Source and path are not the
   same type, and either:

     * Source is a specialization of std::basic_string or std::basic_string_view, or
     * std::iterator_traits<std::decay_t<Source>>::value_type is valid and denotes a
       possibly const-qualified encoding character type (char,
       char8_t,
       \fI(since C++20)\fPchar16_t, char32_t, or wchar_t).

.SH Parameters

   p            - path to append
   str          - string or string view to append
   ptr          - pointer to the beginning of a null-terminated string to append
   x            - single character to append
                  std::basic_string, std::basic_string_view, null-terminated
   source       - multicharacter string, or an input iterator pointing to a
                  null-terminated multicharacter sequence, which represents a path name
                  (either in portable or in native format)
   first, last  - pair of LegacyInputIterators that specify a multicharacter sequence
                  that represents a path name
.SH Type requirements
   -
   InputIt must meet the requirements of LegacyInputIterator.
   -
   The value type of InputIt must be one of the encoded character types (char, wchar_t,
   char16_t and char32_t).
   -
   CharT must be one of the encoded character types (char, wchar_t, char16_t and
   char32_t).

.SH Return value

   *this

.SH Exceptions

   May throw std::bad_alloc if memory allocation fails.

.SH Notes

   Unlike with append() or operator/=, additional directory separators are never
   introduced.

.SH Example


// Run this code

 #include <filesystem>
 #include <iostream>
 #include <string>

 int main()
 {
     std::filesystem::path p1; // an empty path
     p1 += "var"; // does not insert a separator
     std::cout << R"("" + "var" --> )" << p1 << '\\n';
     p1 += "lib"; // does not insert a separator
     std::cout << R"("var" + "lib" --> )" << p1 << '\\n';
     auto str = std::string{"1234567"};
     p1.concat(std::begin(str) + 3, std::end(str) - 1);
     std::cout << "p1.concat --> " << p1 << '\\n';
 }

.SH Output:

 "" + "var" --> "var"
 "var" + "lib" --> "varlib"
 p1.concat --> "varlib456"

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to              Behavior as published              Correct behavior
   LWG 3055 C++17      the specification of concatenating a single     made well-formed
                       character was ill-formed
   LWG 3244 C++17      constraint that Source cannot be path was       added
                       missing

.SH See also

   append     appends elements to the path with a directory separator
   operator/= \fI(public member function)\fP
   operator/  concatenates two paths with a directory separator
   \fI(C++17)\fP    \fI(function)\fP
